![]() |
![]() |
|
15.6.5 Fenster, die nicht verdeckt werden können
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Me.Cursor = Cursors.WaitCursor |
wird bei einer lang andauernden Operation der Mauszeiger als Sanduhr angezeigt. Damit signalisieren Sie dem Anwender, dass das System beschäftigt ist. Mit
| Me.Cursor = Cursors.Default |
schalten Sie nach der Beendigung der Operation wieder in die Standarddarstellung zurück.
Eine andere Alternative bietet die Eigenschaft UseWaitCursor. Dieser übergeben Sie True, um mit der Sanduhr einen länger dauernden Vorgang anzuzeigen und setzen sie nach Abschluss der Operation auf False zurück, also:
| ' zeigt die Sanduhr an |
| Me.UseWaitCursor = True |
| ... |
| ' schaltet den Standardcursor ein |
| Me.UseWaitCursor = False |
In der Klasse Cursors sind die Mausdarstellungen als statische Eigenschaften vordefiniert, die der Eigenschaft Cursor zugewiesen werden können. Die folgende Tabelle gibt nur einen kleinen Auszug aller Möglichkeiten wieder.
| Eigenschaft | Beschreibung |
| Arrow | Der Mauszeiger wird als Pfeil dargestellt. |
| Cross | Der Mauszeiger wird als Fadenkreuz dargestellt. |
| Default | Der Mauszeiger wird als Pfeil dargestellt (entspricht der Einstellung Arrow). |
| WaitCursor | Der Mauszeiger wird als Sanduhr dargestellt. |
In Kapitel 22 dieses Buches werden wir uns mit der Grafikprogrammierung beschäftigen. In diesen Themenkreis fällt auch die Definition von Farben und Fonts. Bis dahin haben wir aber nicht nur die Form, sondern auch bereits alle wichtigen Steuerelemente behandelt. Farben und Schriftarten sind aber elementar bei fast allen Windows-Komponenten. Daher müssen wir uns schon an dieser Stelle die wichtigsten Aspekte der beiden Typen Color und Font ansehen, die beide zum Namespace System.Drawing gehören.
Farbeigenschaften wie BackColor zur Einstellung der Hintergrundfarbe und ForeColor für die Vordergrundfarbe (entspricht der Zeichen- bzw. Schriftfarbe) sind vom Typ der Struktur Color. Ein Blick in die Dokumentation dieser Struktur verrät uns, dass Color nur über einen parameterlosen Standardkonstruktor verfügt:
| Dim myColor As Color = New Color() |
Diesen Konstruktor einzusetzen, ist wenig sinnvoll, weil er nur ein transparentes Schwarz beschreibt, das als »leere« Farbe wahrgenommen wird. Sinnvoller ist es, auf eine der vordefinierten Farben zuzugreifen, die als statische, schreibgeschützte Eigenschaften veröffentlicht werden. Die folgende Tabelle enthält einen exemplarischen Auszug aus dieser Liste.
| Color-Konstante | Beschreibung |
| Black | Schwarz |
| Blue | Blau |
| Green | Grün |
| Red | Rot |
| White | Weiß |
| Yellow | Gelb |
Sehr einfach sind Farben im Eigenschaftsfenster einzustellen. Soll die Form oder eine Komponente (soweit diese auch die Eigenschaften BackColor bzw. ForeColor aufweist) zur Laufzeit die Farbe wechseln, genügt eine einfache Anweisung, wie z. B.:
| Me.BackColor = Color.Blue |
Das Farbschema folgt dem ARGB-Modell (Alpha-Rot-Grün-Blau). Der Alpha-Kanal legt die Transparenz einer Farbe fest. Jeder der vier Kanäle kann durch einen 8-Bit-Wert, also zwischen 0 bis 255 beschrieben werden.
Um eine beliebige Farbe festzulegen, fehlt es an einem passenden Konstruktor. Die Strukturdefinition wäre unvollständig, wenn es nicht eine andere Alternative geben würde, eine Farbe innerhalb der 8-Bit-ARGB-Komponentenwerte festlegen zu können. Hier kommt die überladene statische Methode FromArgb ins Spiel, die jeweils ein Color-Objekt zurückliefert.
Mit der folgenden Anweisung könnten Sie beispielsweise die Hintergrundfarbe der aktuellen Form zur Laufzeit verändern:
| Me.BackColor = Color.FromArgb(100, 25, 180) |
Die Einstellungen BackColor und ForeColor werden von allen Steuerlementen der Form per Vorgabe übernommen. Soll die Vorder- oder Hintergrundfarbe des Controls davon abweichen, müssen Sie das in der gleichnamigen Eigenschaft des Steuerelements einstellen.
Die Eigenschaft Font, die vom gleichnamigen Typ Font ist, wirkt sich auf die Darstellung von Text aus, der im Arbeitsbereich einer Form ausgeben wird. Außerdem wird diese Eigenschaft, wie auch BackColor und ForeColor, von allen untergeordneten Controls der Form übernommen. Font ändert jedoch nicht die Schriftdarstellung in der Titelleiste.
Zum Einstellen eines von der Vorgabe abweichenden Schriftstils markieren Sie im Eigenschaftsfenster Font und klicken auf die Schaltfläche mit den drei Punkten in der Wertespalte. Es öffnet sich ein Dialog, in dem Sie Ihre Änderungen durch Auswahl oder Selektierung treffen.

Hier klicken, um das Bild zu Vergrößern
Abbildung 15.10 Dialog zum Einstellen der Eigenschaft »Font«
Öffnen Sie den Knoten von Font im Eigenschaftsfenster, können Sie auch einzelne Stile editieren, ohne dass der Dialog geöffnet werden muss.
Die Einstellung im Eigenschaftsfenster ist ein Kinderspiel. Etwas schwieriger wird es, wenn Sie programmatisch die Font-Eigenschaft ändern müssen. Um einen vom Standard abweichenden Typ anzugeben, muss dazu ein neues Font-Objekt erzeugt werden, das von Anfang an die gewünschten Eigenschaften aufweist – beispielsweise die Kursivschreibweise. Wegen der vielen Kombinationsmöglichkeiten bietet die Klasse Font insgesamt 14 Konstruktoren an, die den unterschiedlichen Ansprüchen genügen. Drei möchte ich Ihnen an dieser Stelle exemplarisch vorstellen:
| Public Sub New(Font, FontStyle) |
| Public Sub New(String, Single) |
| Public Sub New(String, Single, FontStyle) |
Sehen wir uns den ersten Konstruktor an, dem im ersten Parameter die Referenz auf ein Font-Objekt übergeben wird. Dabei könnte es sich beispielsweise um die Rückgabe der Eigenschaft Font eines Objekts handeln. Im zweiten Parameter wird der Schriftstil festgelegt, der auf der Enumeration FontStyle basiert.
| FontStyle-Mitglied | Beschreibung |
| Bold | Fett formatierter Text |
| Italic | Kursiv formatierter Text |
| Regular | Normaler Text |
| Strikeout | Durchgestrichener Text |
| Underline | Unterstrichener Text |
Angenommen wir wollen die aktuelle Schriftdarstellung auf der Arbeitsfläche einer Form, die mit frm referenziert wird, in eine fett formatierte Ausgabe ändern. Die Anweisung dazu sieht wie folgt aus:
| frm.Font = New Font(frm.Font, FontStyle.Bold) |
Wenn Sie in die .NET-Dokumentation schauen werden Sie feststellen, dass die FontStyle-Enumeration über das Flags-Attribut verfügt und somit jede Konstante der Enumeration durch ein bestimmtes Bit beschrieben wird. Eine gegebene Schrift kann damit gleichzeitig mehrere der in FontStyle definierten Charakteristiken aufweisen. Das ist auch richtig, denn zweifelsfrei kann eine Schrift sowohl kursiv als auch fett sein.
Soll eine Schrift mehrere Merkmale gleichzeitig aufweisen, müssen die einzelnen Enumerations-Mitglieder nur mit dem bitweisen OR-Operator verknüpft werden.:
| myForm.Font = New Font(myForm.Font, FontStyle.Bold Or FontStyle.Italic) |
Die Schrift, die jetzt in myForm dargestellt wird, ist sowohl fett als auch kursiv. Schriftart und -größe entsprechen der ursprünglichen Schrift.
Interessant wird es, innerhalb einer Anweisung eine der Schrifteigenschaften zu invertieren, den Wert also genau umzukehren. Nehmen wir beispielsweise an, Sie möchten erreichen, dass eine Schrift, die aktuell fett angezeigt wird, in Normaldarstellung ausgegeben wird. Bold ist zwar eine Eigenschaft der Klasse Font (wie auch Italic, Strikeout und Underline), hat jedoch keinen Set-Accessor und kann daher nicht direkt verändert werden. Der Weg zum Ziel führt nur über den Konstruktor der Font-Klasse:
| frm.Font = New Font(frm.Font, frm.Font.Style Xor FontStyle.Bold) |
Dem ersten Parameter wird hier die aktuelle Schrift übergeben. Um den zweiten mit dem richtigen Wert zu füttern, wird zunächst die augenblickliche FontStyle-Einstellung abgefragt. Mit dem Xor-Operator verknüpfen wir diesen Wert noch mit der Bitsequenz für die fette Schriftdarstellung: Das von FontStyle.Bold beschriebene Bit wird anschließend innerhalb der Bitsequenz FontStyle invertiert.
Das nachfolgende Beispiel gibt im Arbeitsbereich eines Fensters eine Zeichenfolge aus, wenn in den Arbeitsbereich geklickt wird. Ein wiederholtes Klicken bewirkt, dass sich die Fett- und Kursivdarstellung der Zeichenfolge ändert.
Um die Ausgabe einer Zeichenfolge im Arbeitsbereich des Fensters zu erreichen, müssen wir thematisch etwas vorgreifen und mit Typen arbeiten, die erst weiter hinten in diesem Buch behandelt werden. Aber sehen wir uns zuvor den Code an.
| ' ---------------------------------------------------------- |
| ' Beispiel: ...\Kapitel 15\EditFont |
| ' ---------------------------------------------------------- |
| Public Class Form1 |
| Private newFont As Font = New Font("Arial", 24) |
| Private Sub Form1_Click(ByVal sender As Object, _ |
| ByVal e As EventArgs) Handles MyBase.Click |
| newFont = New Font(newFont, _ |
| newFont.Style Xor FontStyle.Bold Xor FontStyle.Italic) |
| Dim graph As Graphics = Me.CreateGraphics() |
| Me.Refresh() |
| graph.DrawString("Visual Basic macht Spaß!", _ |
| newFont, Brushes.Blue, 0, 0) |
| End Sub |
| End Class |
Der Programmcode konzentriert sich aufgrund der Aufgabenstellung auf den Ereignishandler des Click-Ereignisses der Form. Auf Klassenebene ist nur noch die Variable newFont vom Typ Font deklariert. Das Feld beschreibt die Schriftart »Arial« in einer Größe von 24 Punkten und speichert die aktuelle Einstellung der Schrift, in der die Zeichenfolge ausgegeben wird.
Im Ereignishandler wird zuerst die aktuelle fette und kursive Darstellung invertiert und in newFont gespeichert. Mit der Methode CreateGraphics des Form-Objekts besorgen wir uns anschließend die Referenz auf das Graphics-Objekt unserer Form:
| Dim graph As Graphics = Me.CreateGraphics() |
Graphics ist eine wichtige Klasse des .NET Frameworks, weil sie die Methoden zur Ausgabe von Grafiken und Text auf einer Komponente, also auch der Form, bereitstellt. Im Beispielcode wird die Methode DrawString zum Zeichnen eines Strings benutzt.
| Public Sub DrawString(String, Font, Brush, Single, Single) |
Der erste Parameter erwartet die zu zeichnende Zeichenfolge, der zweite legt das Textformat der Zeichenfolge durch den Typ Font fest. Der dritte Parameter vom Typ Brush ähnelt dem Typ Color, weist aber über die Farbgebung hinaus weitergehende Zeichendarstellungsmöglichkeiten auf. Im Code haben wir diesem Parameter einen als statische Eigenschaft definierten Farbwert der Klasse Brushes übergeben. Die letzten beiden Parametern erwarten die Angabe des linken oberen Ursprungspunktes des zu zeichnenden Textes.
Damit die alte Zeichenfolgedarstellung beim erneuten Klicken auf die Form gelöscht und nicht nur überlagert wird, muss der Arbeitsbereich vor der Neudarstellung mit Refresh gesäubert werden.

Hier klicken, um das Bild zu Vergrößern
Abbildung 15.11 Ausgabe des Beispiels »EditFont«
Eine Zeichenfolge in einer bestimmten Schriftart anzuzeigen setzt natürlich voraus, dass diese auch tatsächlich installiert ist. Das kann aber von Rechner zu Rechner, abhängig von der installierten Software, durchaus sehr unterschiedlich sein. Woher können wir diese Information beziehen?
Die .NET-Klassenbibliothek hat wie selbstverständlich eine Lösung anzubieten: Es ist die Klasse InstalledFontCollection im Namespace System.Drawing.Text. Eine Instanz dieses Typs liefert über die Eigenschaft Families ein Array von FontFamily-Objekten. Jedes dieser Objekte veröffentlicht über seine Name-Eigenschaft den uns bekannten Bezeichner der Schriftart.
Das folgende Beispiel gibt die Liste der installierten Fonts als Text im Clientbereich der Form aus. Sicher würde man dazu in der Praxis ein Steuerelement einsetzen, das zu diesem Zweck bedeutend besser geeignet ist. Aber weil wir mit unseren Möglichkeiten noch nicht so weit vorgedrungen sind, wollen wir uns auch schon mit dieser etwas einfacheren Ausgabe zufrieden geben.
| ' ---------------------------------------------------------- |
| ' Beispiel: ...\Kapitel 15\InstallierteFonts |
| ' ---------------------------------------------------------- |
| Imports System.Drawing.Text |
| Public Class Form1 |
| Private Sub Form1_Click(...) Handles MyBase.Click |
| ' InstalledFontCollection liefert alle auf der aktuellen |
| ' Maschine installierten Schriftarten |
| Dim fontCol As InstalledFontCollection = _ |
| New InstalledFontCollection() |
| ' Array aller installierten Fonts abrufen |
| Dim fontArr() As FontFamily = fontCol.Families |
| Dim result As String = "" |
| ' das Array durchlaufen und aus den Namen der Fonts |
| ' eine Zeichenfolge bilden |
| For i As Integer = 0 To fontArr.Length – 1 |
| result += fontArr(i).Name & vbCrLf |
| Next |
| ' Ausgabe in der Form |
| Dim graph As Graphics = Me.CreateGraphics() |
| graph.DrawString(result, Me.Font, Brushes.Black, 0, 0) |
| End Sub |
| End Class |
Zuerst wird eine Instanz der Klasse InstalledFontCollection erzeugt, die uns mit den gewünschten Informationen versorgt. Im nächsten Schritt wird deren Families-Eigenschaft abgerufen, die ein Array vom Typ FontFamily liefert. Jedes FontFamily-Objekt beschreibt eine der installierten Schriftarten. Den Bezeichner der Schriftart erhalten wir, wenn wir die Eigenschaft Name jedes FontFamily-Objekts abrufen. Das geschieht in einer Schleife.
Alle Fontbezeichner werden in der Variablen result, getrennt durch einen Zeilenumbruch, gesammelt und danach mit der Methode DrawString in den Arbeitsbereich der Form gezeichnet.

Hier klicken, um das Bild zu Vergrößern
Abbildung 15.12 Ausgabe des Beispiels »InstallierteFonts«
Die äußere Abmessung einer Form kann mit den folgenden Eigenschaften beschrieben werden:
| Size |
| Height und Width |
Size gestattet, in einer Anweisung gleichzeitig Breite und Höhe des Fensters in Pixel festzulegen. Diese Eigenschaft ist vom Typ der gleichnamigen Struktur Size. Übergibt man der Eigenschaft einen neuen Wert, bietet es sich an, einen passenden Konstruktor aufzurufen, z. B.:
| Me.Size = New Size(600, 400) |
Dieselbe Fenstergröße erzielen Sie, wenn den beiden Eigenschaften Width und Height die Größenangaben einzeln übergeben werden:
| Me.Width = 600 |
| Me.Height = 400 |
Sie werden die Eigenschaften Width und Height nicht im Eigenschaftsfenster finden. Dennoch können Sie sie im Code manipulieren.
| Hinweis |
|
Width und Height sind nicht die einzigen Eigenschaften, die nicht im Eigenschaftsfenster angezeigt werden, denn grundsätzlich gibt es keine Vorschrift die besagt, dass alle Eigenschaften eines Typs hier angeboten werden müssen. Wir werden uns später noch mit der Entwicklung benutzerdefinierter Steuerelemente beschäftigen. Dort werden Sie erfahren, dass die Anzeige im Eigenschaftsfenster sogar ausdrücklich festgelegt werden muss. |
Wollen Sie verhindern, dass der Anwender eine Form zur Laufzeit über ein bestimmtes Maß hinaus vergrößert oder verkleinert, stellen Sie die Eigenschaften MinimumSize und MaximumSize auf die gewünschten Grenzwerte ein.
Um ein Fenster an einer bestimmten Position des Bildschirms anzuzeigen, stehen mehrere Eigenschaften zur Verfügung:
| StartPosition |
| Location |
| Left und Top |
Die Startposition eines Fensters auf dem Bildschirm wird mit der Eigenschaft StartPosition festgelegt. Dazu wird der Eigenschaft ein Wert aus der Enumeration FormStartPosition übergeben.
| FormStartPosition-Member | Beschreibung |
| CenterParent | Das Formular wird innerhalb eines übergeordneten Formulars zentriert. |
| CenterScreen | Das Formular wird auf dem Bildschirm zentriert angezeigt. |
| Manual | Die Position des Formulars wird durch die Einstellung der Eigenschaft Location festgelegt. |
| WindowsDefaultBounds | Das Formular wird an der Windows-Standardposition positioniert. Die Größe wird von Windows festgelegt, die Einstellungen der Eigenschaften Width/Height bzw. Size der Form werden ignoriert. |
| WindowsDefaultLocation | Das Formular wird an der Windows-Standardposition positioniert. Die Größe der Form entspricht den Einstellungen in Width/Height bzw. Size. Diese Einstellung ist der Standard. |
Zu Beginn einer Windows-Sitzung wird das erste Programmfenster in der linken oberen Ecke des Bildschirms positioniert, jedes weitere um einen bestimmten Betrag weiter rechts unten. Das ist die Vorgabe, wenn nichts anderes bestimmt wird. Dieses Positionierungsverhalten wird durch die beiden Einstellungen WindowsDefaultBounds und WindowsDefaultLocation beschrieben. Beide unterscheiden sich nur darin, in welcher Größe ein Formular nach dem Start angezeigt wird. Wählen Sie WindowsDefaultBounds, werden alle weiteren Angaben bezüglich Position und Größe ignoriert, mit WindowsDefaultLocation wird die Größe der Form aus den Einstellungen der Eigenschaften Width und Height berücksichtigt.
Öffnen wir ein Fenster aus einem anderen heraus – es könnte sich zum Beispiel um ein Dialogfenster handeln – ist insbesondere die Einstellung CenterParent interessant: Der Dialog wird genau mittig über dem aufrufenden positioniert. CenterScreen positioniert eine Form in der Mitte des Bildschirms.
Legen Sie Manual fest, können Sie sowohl die Größe als auch die Position nach eigenem Ermessen festlegen. Location beschreibt dazu die x- und y-Position der Form nach dem Start. Die Angaben sind in Pixel und beziehen sich auf die Position der linken oberen Ecke der Form bezüglich des Ursprungspunktes des Bildschirms (0, 0). Dieser befindet sich in der linken oberen Ecke des Bildschirms.
Left legt den Abstand zwischen dem linken Rand des Fensters und des Bildschirms fest, Top den Abstand zum oberen Rand. Auch diese Eigenschaften werden nicht im Eigenschaftsfenster angeboten. Nichtsdestotrotz sind beide öffentlich. Darüber hinaus gibt es noch zwei ähnliche, positionsbeschreibende Eigenschaften: Right und Bottom, die allerdings schreibgeschützt sind.
Möchten Sie sowohl die Größe als auch die Position eines Fensters gleichzeitig verändern, müssen Sie nicht mehrere Eigenschaftsaufrufe starten, sondern können entweder mit der Eigenschaft Bounds oder mit der Eigenschaft DesktopBounds eine einzeilige Anweisung codieren. Beide sind vom Typ Rectangle und definieren das Fenster als Rechteck einer vorgegebenen Größe an einer bestimmten Position. Mit
| Me.DesktopBounds = New Rectangle(100, 120, 600, 450) |
wird beispielsweise ein Fenster mit den Abmessungen 600 x 450 Pixel beschrieben, das zum linken Rand des Bildschirms einen Abstand von 100 Pixel aufweist und zum oberen Rand einen Abstand von 120 Pixel.
| Hinweis |
|
Wollen Sie die Größe oder die Position eines Fensters ändern, müssen Sie nicht unbedingt Eigenschaftswerte neu festlegen. Es bieten sich hierzu auch die Methoden SetDesktopLocation und SetDesktopBounds an, die dasselbe bewirken. |
Die Größe eines Fensters ist nach dem Öffnen so, wie es in der Eigenschaft Size beschrieben wird. Es ist der Normalzustand. Darüber hinaus können Sie aber auch schon beim Öffnen einer Form oder auch später zur Laufzeit einen anderen Zustand festlegen. Zur Auswahl steht noch die maximierte und die minimierte Anzeige. Festgelegt wird das in der Eigenschaft WindowState, die einen der drei Werte aus der Enumeration FormWindowState annehmen kann, die in Tabelle 15.10 aufgeführt sind.
| FormWindowState-Konstante | Beschreibung |
| Maximized | Das Fenster wird maximiert angezeigt. |
| Minimized | Das Fenster wird minimiert angezeigt. |
| Normal | Das Fenster wird in seiner Standardgröße angezeigt. |
Die weiter oben beschriebenen Eigenschaften zur Festlegung der Größe eines Formulars beziehen sich auf die Außenabmessungen, also einschließlich Rand und Titelleiste. Fügen Sie einer Form Steuerelemente hinzu oder rufen Sie eine grafische Methode auf, um in die Form zu zeichnen, spielen die Außenabmessungen keine Rolle, denn diese Elemente können nur den standardmäßig grauen Arbeitsbereich der Form für sich in Anspruch nehmen. Dieser wird durch die Eigenschaft ClientSize beschrieben und berücksichtigt weder den Außenrahmen noch die Titelleiste. Die Eigenschaft ist ebenfalls vom Typ Size, der die Breite und die Höhe über Width und Height beschreibt. Wird zur Laufzeit der Anwendung der Eigenschaft ClientSize ein anderer Wert zugewiesen, passen sich die Außenabmessungen der Form an die neue Vorgabe an, weil Rahmen und Titelleiste immer konstant sind.
Eine Form zählt zu den Komponenten, die ihrerseits weitere Komponenten (Steuerelemente) beherbergen können. Mit dieser Fähigkeit sind unter anderem auch GroupBox und Panel ausgestattet. Diese Typen haben eines gemeinsam: die Eigenschaft Controls. Damit wird die Referenz auf eine Auflistung vom Typ Control.ControlCollection veröffentlicht, in der die vom Container beherbergten Steuerelemente verwaltet werden. Wir haben es hier zum ersten Mal mit einer verschachtelten Klassendefinition zu tun, denn die Klasse ControlCollection ist innerhalb der Klasse Control definiert.
Die Zugehörigkeit eines Steuerelements zu einer ControlCollection ist von elementarer Bedeutung. Nehmen wir an, Sie hätten einen Button wie folgt instanziert:
| Dim btn As New Button |
Damit ist aber noch keine Anzeige zur Laufzeit garantiert denn es fehlt der Schaltfläche noch eine Voraussetzung: Der Button muss einer ControlCollection hinzugefügt werden – entweder der der Form oder der eines anderen Containers. Damit ein Container wie beispielsweise eine GroupBox in einer Form angezeigt werden kann, muss die GroupBox ihrerseits Mitglied der ControlCollection der Form sein. So schließt sich der Kreis und kann infolgedessen zu einer tief verschachtelten Auflistungshierarchie führen.
Jede ControlCollection hat die üblichen Methoden einer indexbasierten Auflistung zum Hinzufügen, Löschen und für den Zugriff auf die Elemente (Add, Remove, Clear, ...). Mit
| Me.Controls.Add(btn) |
würde die oben instanzierte Schaltfläche also der Steuerelementauflistung der Form hinzugefügt und zur Laufzeit wunschgemäß angezeigt.
Solange sie den Forms Designer benutzen, werden Sie ziemlich selten mit der ControlCollection in Berührung kommen, denn alles Notwendige erledigt das Visual Studio. Sie finden den entsprechenden Programmcode in der Methode InitializeComponent. Sie können die Auflistung aber jederzeit manipulieren, um zur Laufzeit dynamisch Steuerelemente zu erzeugen und danach ein- oder auszublenden – beispielsweise, wenn die Form den aktuellen Bedingungen angepasst werden muss.
Sie haben jetzt einige Eigenschaften eines Form-Objekts kennen gelernt. Es gibt noch eine große Zahl weiterer, auf die wir hier aus Platzgründen nicht weiter eingehen können. Ich möchte Sie aber dazu ermuntern, mit der einen oder anderen Eigenschaft durchaus ein wenig zu experimentieren. Das gilt im Übrigen auch für die Eigenschaften der Controls, denen wir uns später noch widmen werden. Meist können Sie aufgrund des gewählten Eigenschaftsnamens schon die Fähigkeiten, die sich dahinter verbergen, erahnen.
Alle bisher besprochenen Eigenschaften finden Sie zusammenfassend in der folgenden Tabelle. Sie werden im weiteren Verlauf dieses Buches noch einige weitere Eigenschaften kennen lernen, die in dieser Tabelle der Übersicht wegen aber noch nicht enthalten sind.
| Eigenschaft | Typ | Beschreibung |
| BackColor | Color | Beschreibt die Hintergrundfarbe der Form. |
| Bounds | Rectangle | Legt die Größe und Position einer Form fest. |
| ClientSize | Size | Legt die Größe des Clientbereichs einer Form fest. |
| ControlBox | Boolean | Gibt an, ob in der Titelleiste das Systemmenüfeld angezeigt wird. |
| Controls | Control.ControlCollection | Liefert die Referenz auf eine Auflistung aller Steuerelemente, die in einem Container (hier der Form) enthalten sind. |
| Cursor | Cursor | Legt den Cursor fest. |
| DesktopBounds | Rectangle | Ruft Größe und Position der form auf dem Windows-Desktop ab. |
| Font | Font | Legt die Schrift für den Clientbereich und die untergeordneten Controls fest. |
| ForeColor | Color | Beschreibt die Vordergrundfarbe. |
| FormBorderStyle | FormBorderStyle | Legt die Rahmenart der Form fest. |
| Height | Integer | Legt die Höhe fest. |
| Icon | Icon | Legt das symbol für die Form fest. |
| Left | Integer | Legt den Abstand vom linken Rand der Form zum linken Rand des Bildschirms in Pixel fest. |
| Location | Point | Beschreibt die Koordinaten der linken oberen Ecke der Form relativ zur linken oberen Ecke des Bildschirms. |
| MaximizeBox | Boolean | Legt fest, ob die Maximieren-Schaltfläche in der Titelleiste angezeigt wird. |
| MaximumSize | Size | Legt die Maximalgröße der Form fest. |
| MinimizeBox | Boolean | Legt fest, ob die Minimieren-Schaltfläche in der Titelleiste angezeigt wird. |
| MinimumSize | Size | Legt die Minimalgröße der Form fest. |
| Opacity | Double | Beschreibt die Durchlässigkeit einer Form. |
| ShowInTaskbar | Boolean | Gibt an, ob die Form in der Taskleiste abgelegt werden kann. |
| Size | Size | Legt die Größe der Form fest. |
| StartPosition | FormStartPosition | Legt die Position des Fensters zur Laufzeit fest. |
| Top | Integer | Legt den Abstand vom oberen Rand der Form zum oberenRand des Bildschirms in Pixel fest. |
| TopMost | Boolean | Gibt an, ob die Form in der Anwendung als oberstes Fenster angezeigt werden soll. |
| TransparencyKey | Color | Beschreibt, die Farbe für die transparente Anzeige der Form. |
| UseWaitCursor | Boolean | Legt fest, ob die sanduhr als Mauszeiger angezeigt werden soll oder nicht. |
| Width | Integer | Legt die Breite fest. |
| WindowState | FormWindowState | Legt den Anzeigestatus des fensters fest. |
| << zurück |
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
Copyright © Galileo Press 2007
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken.
Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die
gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich
geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung,
Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.